import java.util.Arrays;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description: 第 K 小的和
 * User: DELL
 * Date: 2024-05-09
 * Time: 15:47
 */
public class Main5 {
    static int[] arrN;
    static int[] arrM;
    static int n;
    static int m;
    static long k;

    /**
     * 本题其实可以先排序，排序完后针对 K 进行整体二分，之后展开遍历，遍历过程中也继续
     * 利用遍历 arrN 数组，同时针对每一个元素，利用二分查找符合条件的个数即可，即两次二分一次遍历
     * 优化后也可以利用 arrN 和 arrM 都是有序的特性，直接遍历寻找，就如下面这个方法
     * 将整体复杂度变成了 二分 * O（n + m）了，效率更高
     *
     * @param args
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        k = scanner.nextLong();
        arrN = new int[n];
        arrM = new int[m];
        for (int i = 0; i < n; i++) {
            arrN[i] = scanner.nextInt();
        }
        for (int i = 0; i < m; i++) {
            arrM[i] = scanner.nextInt();
        }
        Arrays.sort(arrN);
        Arrays.sort(arrM);
        // 进行二分
        long left = 2;
        long right = 2000000000L;
        while (left < right) {
            long mid = (left + right) >> 1;
            if (check(mid)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        System.out.println(left);
    }

    /**
     * 满足小于等于 num 的数 大于等于 k 个就返回 true
     *
     * @return
     */
    private static boolean check(long num) {
        long temp = 0;
        int indexN = 0;
        int indexM = m - 1;
        while (indexN < n && indexM >= 0) {
            long sum = (long) arrN[indexN] + arrM[indexM];
            if (sum <= num) {
                temp += indexM + 1;
                if (temp >= k) {
                    return true;
                }
                indexN++;
            } else {
                indexM--;
            }
        }
        return false;
    }
}
